﻿package frEngine.animateControler.particleControler.animate
{
    import __AS3__.vec.*;
    import flash.geom.*;
    import frEngine.animateControler.particleControler.*;
    import frEngine.shader.filters.*;

    public class UseUvOffset extends Object implements IParticleAnimate
    {
        private var startU:Number;
        private var startV:Number;
        private var disU:Number;
        private var disV:Number;
        private var isOpen:Boolean;
        private var _smoothData:Vector.<uint>;
        public static const instance:UseUvOffset = new UseUvOffset;

        public function UseUvOffset()
        {
            return;
        }// end function

        public function get objClass() : Class
        {
            return UseUvOffset;
        }// end function

        public function canOpen(param1:ParticleParams) : Boolean
        {
            return true;
        }// end function

        private function resetUvOffset(param1:ParticleStatus) : void
        {
            var _loc_4:ParticleItem = null;
            var _loc_5:int = 0;
            var _loc_2:* = param1.particleList;
            var _loc_3:* = _loc_2.length;
            _loc_5 = 0;
            while (_loc_5 < _loc_3)
            {
                
                _loc_4 = _loc_2[_loc_5];
                if (_loc_4.visible && _loc_4.toUpdate)
                {
                    var _loc_6:int = 0;
                    _loc_4.vOffset = 0;
                    _loc_4.uOffset = _loc_6;
                }
                _loc_5++;
            }
            return;
        }// end function

        private function updateNoSmooth(param1:ParticleStatus) : void
        {
            var _loc_4:ParticleItem = null;
            var _loc_5:Vector3D = null;
            var _loc_7:Number = NaN;
            var _loc_2:* = param1.particleList;
            var _loc_3:* = _loc_2.length;
            var _loc_6:int = 0;
            while (_loc_6 < _loc_3)
            {
                
                _loc_4 = _loc_2[_loc_6];
                if (_loc_4.visible && _loc_4.toUpdate)
                {
                    _loc_7 = _loc_4.lifeRate;
                    _loc_4.uOffset = this.startU + _loc_7 * this.disU;
                    _loc_4.vOffset = this.startV + _loc_7 * this.disV;
                }
                _loc_6++;
            }
            return;
        }// end function

        private function updateSmooth(param1:ParticleStatus) : void
        {
            var _loc_4:ParticleItem = null;
            var _loc_5:Vector3D = null;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:Number = NaN;
            var _loc_10:Number = NaN;
            var _loc_11:Number = NaN;
            var _loc_2:* = param1.particleList;
            var _loc_3:* = _loc_2.length;
            var _loc_6:int = 0;
            while (_loc_6 < _loc_3)
            {
                
                _loc_4 = _loc_2[_loc_6];
                if (_loc_4.visible && _loc_4.toUpdate)
                {
                    _loc_7 = _loc_4.lifeRate * 128;
                    _loc_8 = this._smoothData[_loc_7];
                    _loc_9 = _loc_8 / 255;
                    _loc_10 = this.startU + _loc_9 * this.disU;
                    _loc_4.uOffset = _loc_10 - int(_loc_10);
                    _loc_11 = this.startV + _loc_9 * this.disV;
                    _loc_4.vOffset = _loc_11 - int(_loc_11);
                }
                _loc_6++;
            }
            return;
        }// end function

        public function update(param1:ParticleStatus) : void
        {
            if (param1.openUvOffset)
            {
                this.resetUvOffset(param1);
            }
            else if (this.isOpen)
            {
                if (this._smoothData)
                {
                    this.updateSmooth(param1);
                }
                else
                {
                    this.updateNoSmooth(param1);
                }
            }
            return;
        }// end function

        public function init(param1:ParticleStatus, param2:ParticleParams) : void
        {
            var _loc_3:* = param2.uvOffset;
            this.isOpen = param2.uvOffset != null;
            if (this.isOpen)
            {
                this.startU = _loc_3.x;
                this.startV = _loc_3.y;
                this.disU = _loc_3.z;
                this.disV = _loc_3.w;
                this._smoothData = param2.offsetSmoothData;
            }
            if (param2.uvFingerConst)
            {
                this.initFingerUv(param1, param2);
            }
            return;
        }// end function

        private function initFingerUv(param1:ParticleStatus, param2:ParticleParams) : void
        {
            var _loc_7:ParticleItem = null;
            var _loc_11:int = 0;
            var _loc_3:* = param2.surfaceData["" + FilterName_ID.PARAM3_ID + ":4:true"];
            var _loc_4:* = param2.numOfmeshVertex;
            var _loc_5:* = param1.particleList;
            var _loc_6:* = _loc_5.length;
            var _loc_8:* = param2.uvFingerConst.x;
            var _loc_9:* = param2.uvFingerConst.y;
            var _loc_10:int = 0;
            while (_loc_10 < _loc_6)
            {
                
                _loc_7 = _loc_5[_loc_10];
                _loc_11 = _loc_10 * _loc_4 * 4;
                _loc_7.fingerU = _loc_3[_loc_11 + 2] / _loc_8;
                _loc_7.fingerV = _loc_3[_loc_11 + 3] / _loc_9;
                _loc_10++;
            }
            return;
        }// end function

    }
}
